///*
// * TIFFDecoderModifiedHuffman
// *
// * Copyright (c) 2002, 2003, 2004, 2005, 2006 Marco Schmidt.
// * All rights reserved.
// */

//namespace Petra.Gis.ImagingServices.Tiff
//{
//  /**
// * A TIFF decoder for files compresseed with the <em>Modified Huffman</em> method
// * (also known as <em>CCITT 1D Modified Huffman Run Length Encoding</em>).
// * This compression algorithm has the value <code>2</code> 
// * in the compression tag of an image file directory.
// * Only bilevel images can be encoded with that method.
// * @author Marco Schmidt
// * @since 0.9.0
// */
//  public class TIFFDecoderModifiedHuffman : Compression
//  {


//    public TIFFDecoderModifiedHuffman()
//      :base(){}


//    public TIFFDecoderModifiedHuffman(Image currImage)
//      : base(currImage)
//    { }



//    //public override Compression CreateCompression(TIFFCodec tifcodec, IPixelImage currImage, int currentTile)
//    public override Compression CreateCompression(Image currImage)
//    {
//      return new TIFFDecoderModifiedHuffman(currImage);
    
//    }



//    //private DataInput din;
//    private int bitBuffer;
//    private int numBufferedBits;

//    public override void decode()
//    //throws 		InvalidFileStructureException,		IOException
//    {
//      byte[] row = new byte[getBytesPerRow()];
//      for (int y = getY1(); y <= getY2(); y++)
//      {
//        decodeRow(row);
//        putBytes(row, 0, row.Length);
//      }
//    }

//    private int decodeBlackRun()
//    //throws		InvalidFileStructureException,		IOException
//    {
//      return decodeRun(TIFFFaxCodes.BLACK_CODES, TIFFFaxCodes.MIN_BLACK_CODE_SIZE);
//    }

//    private void decodeRow(byte[] row)
//    //throws 		InvalidFileStructureException,		IOException
//    {
//      reset();
//      bool black = false;
//      int index = 0;
//      do
//      {
//        // this will hold the accumulated run length for the current 
//        // color at the end of this loop iteration
//        int completeRunLength = 0;
//        // get run lengths regarding current color until one is smaller than 64
//        int runLength;
//        do
//        {
//          if (black)
//          {
//            runLength = decodeBlackRun();
//          }
//          else
//          {
//            runLength = decodeWhiteRun();
//          }
//          completeRunLength += runLength;
//        }
//        while (runLength >= 64);
//        // pick color value for output row
//        byte value;
//        if (black)
//        {
//          value = (byte)MemoryBilevelImage.BiColorType.BLACK;
//        }
//        else
//        {
//          value = (byte)MemoryBilevelImage.BiColorType.WHITE;
//        }
//        // fill row buffer with value
//        while (completeRunLength-- > 0)
//        {
//          row[index++] = value;
//        }
//        // switch colors (black to white or vice versa)
//        black = !black;
//      }
//      while (index < row.Length);
//    }

//    private int decodeRun(int[][][] codes, int minCodeSize)
//    //throws 		InvalidFileStructureException,		IOException
//    {
//      int code = readBits(minCodeSize);
//      //int currentCodeSize = minCodeSize;
//      for (int i = 0; i < codes.Length; i++)
//      {
//        int[][] data = codes[i];
//        int j = 0;
//        int LENGTH = data.Length;
//        while (j < LENGTH)
//        {
//          int[] pair = data[j++];
//          if (pair[TIFFFaxCodes.INDEX_CODE_WORD] == code)
//          {
//            return pair[TIFFFaxCodes.INDEX_CODE_VALUE];
//          }
//        }
//        code = (code << 1) | readBit();
//      }
//      throw new InvalidFileStructureException("Could not identify Huffman code in TIFF file.");
//    }

//    private int decodeWhiteRun()
//    //throws		InvalidFileStructureException,		IOException
//    {
//      return decodeRun(TIFFFaxCodes.WHITE_CODES, TIFFFaxCodes.MIN_WHITE_CODE_SIZE);
//    }


//    //public void initialize()
//    ////throws 		IOException, 		MissingParameterException
//    //{
//    //  base.initialize();
//    //  din = getInput();
//    //}

//    private int readBit() 
//    //throws IOException
//  {
//    int result;
//    if (numBufferedBits == 0)
//    {
//      bitBuffer = _tiffReader.ReadByte();
//      if ((bitBuffer & 0x80) == 0)
//      {
//        result = 0;
//      }
//      else
//      {
//        result = 1;
//      }
//      bitBuffer &= 0x7f;
//      numBufferedBits = 7;
//    }
//    else
//    {
//      numBufferedBits--;
//      result = bitBuffer >> numBufferedBits;
//      bitBuffer &= (1 << numBufferedBits) - 1;
//    }
//    return result;
//  }

//    private int readBits(int number) 
//    //throws IOException
//  {
//    // make sure there are at least number bits
//    while (numBufferedBits < number)
//    {
//      int b = _tiffReader.ReadByte();
//      bitBuffer = (bitBuffer << 8) | b;
//      numBufferedBits += 8;
//    }
//    numBufferedBits -= number;
//    int result = bitBuffer >> numBufferedBits;
//    bitBuffer &= (1 << numBufferedBits) - 1;
//    return result;
//  }

//    private void reset()
//    {
//      bitBuffer = 0;
//      numBufferedBits = 0;
//    }


//    public override CompressionType[] CompressionTypes
//    {
//      get { return new CompressionType[] {CompressionType.CCITTRLE}; }
//    }
//  }
//}